home *** CD-ROM | disk | FTP | other *** search
/ PC World 2007 June / PCWorld_2007-06_cd.bin / v cisle / tclock / tclocklight-040702-3.exe / source / common / utl.c < prev   
C/C++ Source or Header  |  2004-05-09  |  11KB  |  500 lines
  1. /*-------------------------------------------------------------
  2.   utl.c : misc functions
  3.   (C) 1997-2003 Kazuto Sato
  4.   Please read readme.txt about the license.
  5.   
  6.   Written by Kazubon, Nanashi-san
  7. ---------------------------------------------------------------*/
  8.  
  9. #include "common.h"
  10.  
  11. extern HINSTANCE g_hInst;
  12. extern char g_mydir[];
  13.  
  14. /*---------------------------------------------
  15.    add a file name to a path
  16.    C:\aaa\bbb + ccc -> C:\aaa\bbb\ccc
  17. ----------------------------------------------*/
  18. void add_title(char *path, const char *title)
  19. {
  20.     char *dp = path;
  21.     const char *sp = title;
  22.     
  23.     if(*dp == 0) ;
  24.     else if(*sp == '\\' && *(sp + 1) == '\\') ;
  25.     else if(*sp == '\\')
  26.     {
  27.         if(*dp && *(dp + 1) == ':') dp += 2;
  28.     }
  29.     else
  30.     {
  31.         while(*sp)
  32.         {
  33.             if(*sp == ':') break;
  34.             sp++;
  35.         }
  36.         
  37.         if(*sp == 0)
  38.         {
  39.             while(*dp)
  40.             {
  41.                 if((*dp == '\\' || *dp == '/') && *(dp + 1) == 0)
  42.                 {
  43.                     break;
  44.                 }
  45.                 dp = CharNext(dp);
  46.             }
  47.             *dp++ = '\\';
  48.         }
  49.     }
  50.     sp = title;
  51.     while(*sp) *dp++ = *sp++;
  52.     *dp = 0;
  53. }
  54.  
  55. /*-------------------------------------------
  56.   remove a file name from a path
  57. ---------------------------------------------*/
  58. void del_title(char *path)
  59. {
  60.     char *p, *ep;
  61.  
  62.     p = ep = path;
  63.     while(*p)
  64.     {
  65.         if(*p == '\\' || *p == '/')
  66.         {
  67.             if(p > path && *(p - 1) == ':') ep = p + 1;
  68.             else ep = p;
  69.         }
  70.         p = CharNext(p);
  71.     }
  72.     *ep = 0;
  73. }
  74.  
  75. /*------------------------------------------------
  76.   compare file extensions
  77. --------------------------------------------------*/
  78. int ext_cmp(const char *fname, const char *ext)
  79. {
  80.     const char* p, *sp;
  81.     
  82.     sp = NULL; p = fname;
  83.     while(*p)
  84.     {
  85.         if(*p == '.') sp = p;
  86.         else if(*p == '\\' || *p == '/') sp = NULL;
  87.         p = CharNext(p);
  88.     }
  89.     
  90.     if(sp == NULL) sp = p;
  91.     if(*sp == '.') sp++;
  92.     
  93.     while(1)
  94.     {
  95.         if(*sp == 0 && *ext == 0) break;
  96.         if(toupper(*sp) != toupper(*ext))
  97.             return (toupper(*sp) - toupper(*ext));
  98.         sp++; ext++;
  99.     }
  100.     return 0;
  101. }
  102.  
  103. /*------------------------------------------------
  104.   retrieve and delete file extension
  105. --------------------------------------------------*/
  106. void del_ext(char* ext, char *fname)
  107. {
  108.     char* p, *sp;
  109.     
  110.     sp = NULL; p = fname;
  111.     while(*p)
  112.     {
  113.         if(*p == '.') sp = p;
  114.         else if(*p == '\\' || *p == '/') sp = NULL;
  115.         p = CharNext(p);
  116.     }
  117.     
  118.     if(sp == NULL) sp = p;
  119.     if(*sp == '.') { *sp = 0; sp++; }
  120.     
  121.     while(*sp) *ext++ = *sp++;
  122.     *ext = 0;
  123. }
  124.  
  125. /*------------------------------------------------
  126.   retreive a token from a string with comma delimiter 
  127. --------------------------------------------------*/
  128. int parse(char *dst, const char *src, int n, int nMax)
  129. {
  130.     char *dp;
  131.     int i;
  132.     
  133.     for(i = 0; i < n; i++)
  134.     {
  135.         while(*src && *src != ',') src++;
  136.         if(*src == ',') src++;
  137.     }
  138.     if(*src == 0)
  139.     {
  140.         *dst = 0; return 1;
  141.     }
  142.     
  143.     while(*src == ' ') src++;
  144.     
  145.     dp = dst;
  146.     for(i = 0; *src && *src != ',' && i < nMax - 1; i++)
  147.         *dst++ = *src++;
  148.     *dst = 0;
  149.     
  150.     while(dst != dp)
  151.     {
  152.         dst--;
  153.         if(*dst == ' ') *dst = 0;
  154.         else break;
  155.     }
  156.     
  157.     return 0;
  158. }
  159.  
  160. /*------------------------------------------------
  161.   retreive a token from a string with space delimiter 
  162. --------------------------------------------------*/
  163. void parsespace(char *dst, const char *src, int n, int nMax)
  164. {
  165.     char quot;
  166.     int i;
  167.     
  168.     for(i = 0; i < n; i++)
  169.     {
  170.         quot = 0;
  171.         if(*src == '\"' || *src == '\'')
  172.         {
  173.             quot = *src; src++;
  174.         }
  175.         while(*src && *src != '\r' && *src != '\n')
  176.         {
  177.             if(quot)
  178.             {
  179.                 if(*src == quot) { src++; break; }
  180.             }
  181.             else if(*src == ' ' || *src == '\t') break;
  182.             src++;
  183.         }
  184.         while(*src == ' ' || *src == '\t') src++;
  185.     }
  186.     
  187.     quot = 0;
  188.     if(*src == '\"' || *src == '\'')
  189.     {
  190.         quot = *src; src++;
  191.     }
  192.     for(i = 0; i < nMax - 1 &&
  193.         *src && *src != '\r' && *src != '\n'; i++)
  194.     {
  195.         if(quot)
  196.         {
  197.             if(*src == quot) break;
  198.         }
  199.         else if(*src == ' ' || *src == '\t') break;
  200.         *dst++ = *src++;
  201.     }
  202.     *dst = 0;
  203. }
  204.  
  205. /*------------------------------------------------
  206.    aaa\0bbb\0 + ccc\0 -> aaa\0bbb\0ccc\0\0
  207. --------------------------------------------------*/
  208. void str0cat(char* dst, const char* src)
  209. {
  210.     char* p;
  211.     p = dst;
  212.     while(*p) { while(*p) p++; p++; }
  213.     strcpy(p, src);
  214.     while(*p) p++; p++; *p = 0;
  215. }
  216.  
  217. /*------------------------------------------------
  218.   the string consists of digits?
  219. --------------------------------------------------*/
  220. int isdigitstr(const char *p)
  221. {
  222.     if(*p == 0) return 0;
  223.     while(*p)
  224.     {
  225.         if(!('0' <= *p && *p <= '9')) return 0;
  226.         p++;
  227.     }
  228.     return 1;
  229. }
  230.  
  231. /*------------------------------------------------
  232.   advance pointer to next line
  233. --------------------------------------------------*/
  234. const char* nextline(const char* p)
  235. {
  236.     while(*p && *p != '\r' && *p != '\n') p++;
  237.     if(*p == '\r')
  238.     {
  239.         p++;
  240.         if(*p == '\n') p++;
  241.     }
  242.     else if(*p) p++;
  243.     return p;
  244. }
  245.  
  246. /*------------------------------------------------
  247.   return taskbar window handle
  248. --------------------------------------------------*/
  249. HWND GetTaskbarWindow(void)
  250. {
  251.     return FindWindow("Shell_TrayWnd", "");
  252. }
  253.  
  254. /*------------------------------------------------
  255.   return clock window handle
  256. --------------------------------------------------*/
  257. HWND GetClockWindow(void)
  258. {
  259.     HWND hwnd;
  260.     
  261.     // task bar
  262.     hwnd = GetTaskbarWindow();
  263.     if(!hwnd) return NULL;
  264.     // tray
  265.     hwnd = FindWindowEx(hwnd, NULL, "TrayNotifyWnd", NULL);
  266.     if(!hwnd) return NULL;
  267.     // clock
  268.     hwnd = FindWindowEx(hwnd, NULL, "TrayClockWClass", NULL);
  269.     return hwnd;
  270. }
  271.  
  272. /*------------------------------------------------
  273.    return TClock main window handle
  274. --------------------------------------------------*/
  275. HWND GetTClockMainWindow(void)
  276. {
  277.     return FindWindow(CLASS_TCLOCKMAIN, TITLE_TCLOCKMAIN);
  278. }
  279.  
  280. /*------------------------------------------------
  281.   send a string to other module
  282. --------------------------------------------------*/
  283. void SendStringToOther(HWND hwnd, HWND hwndFrom,
  284.     const char *s, int type)
  285. {
  286.     COPYDATASTRUCT cds;
  287.     
  288.     cds.dwData = type;
  289.     cds.cbData = strlen(s) + 1;
  290.     cds.lpData = (LPVOID)s;
  291.     
  292.     if(hwnd && IsWindow(hwnd))
  293.         SendMessage(hwnd, WM_COPYDATA, (WPARAM)hwndFrom,
  294.             (LPARAM)&cds);
  295. }
  296.  
  297. void SendStringToOtherW(HWND hwnd, HWND hwndFrom,
  298.     const wchar_t *s, int type)
  299. {
  300.     COPYDATASTRUCT cds;
  301.     
  302.     cds.dwData = type;
  303.     cds.cbData = (wcslen(s) + 1) * sizeof(wchar_t);
  304.     cds.lpData = (LPVOID)s;
  305.     
  306.     if(hwnd && IsWindow(hwnd))
  307.         SendMessage(hwnd, WM_COPYDATA, (WPARAM)hwndFrom,
  308.             (LPARAM)&cds);
  309. }
  310.  
  311. /*------------------------------------------------
  312.   the file exists ?
  313. --------------------------------------------------*/
  314. BOOL IsFile(const char* fname)
  315. {
  316.     WIN32_FIND_DATA fd;
  317.     HANDLE hfind;
  318.     
  319.     hfind = FindFirstFile(fname, &fd);
  320.     if(hfind != INVALID_HANDLE_VALUE)
  321.     {
  322.         FindClose(hfind); return TRUE;
  323.     }
  324.     return FALSE;
  325. }
  326.  
  327. /*-------------------------------------------
  328.   check Windows 95/98/Me/NT4/2000/XP
  329. ---------------------------------------------*/
  330. int CheckWinVersion(void)
  331. {
  332.     DWORD dw;
  333.     int ret;
  334.     
  335.     dw = GetVersion();
  336.     ret = 0;
  337.     if(dw & 0x80000000)
  338.     {
  339.         ret |= WIN95;
  340.         if(LOBYTE(LOWORD(dw)) >= 4 && HIBYTE(LOWORD(dw)) >= 10)
  341.             ret |= WIN98;
  342.         if(LOBYTE(LOWORD(dw)) >= 4 && HIBYTE(LOWORD(dw)) >= 90)
  343.             ret |= WINME;
  344.     }
  345.     else
  346.     {
  347.         ret |= WINNT;
  348.         if(LOBYTE(LOWORD(dw)) >= 5) ret |= WIN2000;
  349.         if(LOBYTE(LOWORD(dw)) >= 5 && HIBYTE(LOWORD(dw)) >= 1)
  350.             ret |= WINXP;
  351.     }
  352.     
  353.     return ret;
  354. }
  355.  
  356. /*------------------------------------------------
  357.   IE 4 or later ?
  358. --------------------------------------------------*/
  359. BOOL IsIE4(void)
  360. {
  361.     HWND hwnd;
  362.     DWORD dw;
  363.     
  364.     dw = GetRegLong(HKEY_CURRENT_USER,
  365.         "Software\\Microsoft\\Windows\\CurrentVersion\\Policies\\Explorer",
  366.         "ClassicShell", 0);
  367.     if(dw) return TRUE;
  368.     
  369.     hwnd = FindWindow("Shell_TrayWnd", NULL);
  370.     if(hwnd == NULL) return FALSE;
  371.     hwnd = FindWindowEx(hwnd, NULL, "ReBarWindow32", NULL);
  372.     if(hwnd != NULL) return TRUE;
  373.     return FALSE;
  374. }
  375.  
  376. /*-------------------------------------------
  377.   using XP Theme ?
  378. ---------------------------------------------*/
  379. BOOL IsXPVisualStyle(void)
  380. {
  381.     char s[10];
  382.     
  383.     if(GetRegStr(HKEY_CURRENT_USER,
  384.         "Software\\Microsoft\\Windows\\CurrentVersion\\ThemeManager",
  385.         "ThemeActive", s, 10, "") > 0)
  386.     {
  387.         if(strcmp(s, "0") != 0) return TRUE;
  388.     }
  389.     return FALSE;
  390. }
  391.  
  392. /*-------------------------------------------
  393.   SetForegroundWindow for Windows98
  394. ---------------------------------------------*/
  395. void SetForegroundWindow98(HWND hwnd)
  396. {
  397.     DWORD dwVer;
  398.     
  399.     dwVer = GetVersion();
  400.     if(((dwVer & 0x80000000) && 
  401.            LOBYTE(LOWORD(dwVer)) >= 4 && HIBYTE(LOWORD(dwVer)) >= 10) ||
  402.        (!(dwVer & 0x80000000) && LOBYTE(LOWORD(dwVer)) >= 5)) // Win98/2000
  403.     {
  404.         DWORD thread1, thread2;
  405.         DWORD pid;
  406.         thread1 = GetWindowThreadProcessId(
  407.             GetForegroundWindow(), &pid);
  408.         thread2 = GetCurrentThreadId();
  409.         AttachThreadInput(thread2, thread1, TRUE);
  410.         SetForegroundWindow(hwnd);
  411.         AttachThreadInput(thread2, thread1, FALSE);
  412.         BringWindowToTop(hwnd);
  413.     }
  414.     else  // Win95/NT
  415.         SetForegroundWindow(hwnd);
  416. }
  417.  
  418. /*------------------------------------------------
  419.    adjust the window position
  420. --------------------------------------------------*/
  421. void SetMyDialgPos(HWND hwnd, int xLen, int yLen)
  422. {
  423.     HWND hwndTray;
  424.     RECT rc, rcTray;
  425.     int wscreen, hscreen, wProp, hProp;
  426.     int x, y;
  427.  
  428.     GetWindowRect(hwnd, &rc);
  429.     wProp = rc.right - rc.left;
  430.     hProp = rc.bottom - rc.top;
  431.     
  432.     wscreen = GetSystemMetrics(SM_CXSCREEN);
  433.     hscreen = GetSystemMetrics(SM_CYSCREEN);
  434.     
  435.     hwndTray = FindWindow("Shell_TrayWnd", NULL);
  436.     if(hwndTray == NULL) return;
  437.     GetWindowRect(hwndTray, &rcTray);
  438.     if(rcTray.right - rcTray.left > 
  439.         rcTray.bottom - rcTray.top)
  440.     {
  441.         x = wscreen - wProp - xLen;
  442.         if(rcTray.top < hscreen / 2)
  443.             y = rcTray.bottom + yLen;
  444.         else
  445.             y = rcTray.top - hProp - yLen;
  446.         if(y < 0) y = 0;
  447.     }
  448.     else
  449.     {
  450.         y = hscreen - hProp - yLen;
  451.         if(rcTray.left < wscreen / 2)
  452.             x = rcTray.right + xLen;
  453.         else
  454.             x = rcTray.left - wProp - xLen;
  455.         if(x < 0) x = 0;
  456.     }
  457.     
  458.     MoveWindow(hwnd, x, y, wProp, hProp, FALSE);
  459. }
  460.  
  461. /*-------------------------------------------
  462.   for debugging
  463. ---------------------------------------------*/
  464. void WriteDebug(const char* s)
  465. {
  466.     HFILE hf;
  467.     char fname[MAX_PATH], *title = "DEBUG.TXT";
  468.  
  469.     GetModuleFileName(g_hInst, fname, MAX_PATH);
  470.     del_title(fname);
  471.     add_title(fname, title);
  472.     hf = _lopen(fname, OF_WRITE);
  473.     if(hf == HFILE_ERROR)
  474.         hf = _lcreat(fname, 0);
  475.     if(hf == HFILE_ERROR) return;
  476.     _llseek(hf, 0, 2);
  477.     _lwrite(hf, s, strlen(s));
  478.     _lwrite(hf, "\x0d\x0a", 2);
  479.     _lclose(hf);
  480. }
  481.  
  482. void WriteDebugW(const wchar_t* s)
  483. {
  484.     HFILE hf;
  485.     char fname[MAX_PATH], *title = "DEBUG.TXT";
  486.  
  487.     GetModuleFileName(g_hInst, fname, MAX_PATH);
  488.     del_title(fname);
  489.     add_title(fname, title);
  490.     hf = _lopen(fname, OF_WRITE);
  491.     if(hf == HFILE_ERROR)
  492.         hf = _lcreat(fname, 0);
  493.     if(hf == HFILE_ERROR) return;
  494.     _llseek(hf, 0, 2);
  495.     _lwrite(hf, (LPCSTR)s, wcslen(s)*sizeof(wchar_t));
  496.     _lwrite(hf, (LPCSTR)L"\x0d\x0a", wcslen(L"\x0d\x0a")*sizeof(wchar_t));
  497.     _lclose(hf);
  498. }
  499.  
  500.